/***************************************************************************/
/*                                                                         */
/*  ttload.c                                                               */
/*                                                                         */
/*    Load the basic TrueType tables, i.e., tables that can be either in   */
/*    TTF or OTF fonts (body).                                             */
/*                                                                         */
/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
/*                                                                         */
/*  This file is part of the FreeType project, and may only be used,       */
/*  modified, and distributed under the terms of the FreeType project      */
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/***************************************************************************/


#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
#include FT_TRUETYPE_TAGS_H
#include "ttload.h"

#include "sferrors.h"


/*************************************************************************/
/*                                                                       */
/* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
/* messages during execution.                                            */
/*                                                                       */
#undef  FT_COMPONENT
#define FT_COMPONENT trace_ttload


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_lookup_table                                               */
/*                                                                       */
/* <Description>                                                         */
/*    Looks for a TrueType table by name.                                */
/*                                                                       */
/* <Input>                                                               */
/*    face :: A face object handle.                                      */
/*                                                                       */
/*    tag  :: The searched tag.                                          */
/*                                                                       */
/* <Return>                                                              */
/*    A pointer to the table directory entry.  0 if not found.           */
/*                                                                       */
FT_LOCAL_DEF(TT_Table)
tt_face_lookup_table(TT_Face face,
                     FT_ULong tag)
{
    TT_Table entry;
    TT_Table limit;
    #ifdef FT_DEBUG_LEVEL_TRACE
    FT_Bool zero_length = FALSE;
    #endif


    FT_TRACE4(("tt_face_lookup_table: %08p, `%c%c%c%c' -- ",
               face,
               (FT_Char)(tag >> 24),
               (FT_Char)(tag >> 16),
               (FT_Char)(tag >> 8),
               (FT_Char)(tag)));

    entry = face->dir_tables;
    limit = entry + face->num_tables;

    for (; entry < limit; entry++)
    {
        /* For compatibility with Windows, we consider    */
        /* zero-length tables the same as missing tables. */
        if (entry->Tag == tag)
        {
            if (entry->Length != 0)
            {
                FT_TRACE4(("found table.\n"));
                return entry;
            }
            #ifdef FT_DEBUG_LEVEL_TRACE
            zero_length = TRUE;
            #endif
        }
    }

    #ifdef FT_DEBUG_LEVEL_TRACE
    if (zero_length)
        FT_TRACE4(("ignoring empty table\n"));
    else
        FT_TRACE4(("could not find table\n"));
    #endif

    return NULL;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_goto_table                                                 */
/*                                                                       */
/* <Description>                                                         */
/*    Looks for a TrueType table by name, then seek a stream to it.      */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A face object handle.                                    */
/*                                                                       */
/*    tag    :: The searched tag.                                        */
/*                                                                       */
/*    stream :: The stream to seek when the table is found.              */
/*                                                                       */
/* <Output>                                                              */
/*    length :: The length of the table if found, undefined otherwise.   */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_goto_table(TT_Face face,
                   FT_ULong tag,
                   FT_Stream stream,
                   FT_ULong * length)
{
    TT_Table table;
    FT_Error error;


    table = tt_face_lookup_table(face, tag);
    if (table)
    {
        if (length)
            *length = table->Length;

        if (FT_STREAM_SEEK(table->Offset))
            goto Exit;
    }
    else
        error = SFNT_Err_Table_Missing;

Exit:
    return error;
}


/* Here, we                                                         */
/*                                                                  */
/* - check that `num_tables' is valid (and adjust it if necessary)  */
/*                                                                  */
/* - look for a `head' table, check its size, and parse it to check */
/*   whether its `magic' field is correctly set                     */
/*                                                                  */
/* - errors (except errors returned by stream handling)             */
/*                                                                  */
/*     SFNT_Err_Unknown_File_Format:                                */
/*       no table is defined in directory, it is not sfnt-wrapped   */
/*       data                                                       */
/*     SFNT_Err_Table_Missing:                                      */
/*       table directory is valid, but essential tables             */
/*       (head/bhed/SING) are missing                               */
/*                                                                  */
static FT_Error
check_table_dir(SFNT_Header sfnt,
                FT_Stream stream)
{
    FT_Error error;
    FT_UShort nn, valid_entries = 0;
    FT_UInt has_head = 0, has_sing = 0, has_meta = 0;
    FT_ULong offset = sfnt->offset + 12;

    static const FT_Frame_Field table_dir_entry_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE TT_TableRec

        FT_FRAME_START(16),
        FT_FRAME_ULONG(Tag),
        FT_FRAME_ULONG(CheckSum),
        FT_FRAME_ULONG(Offset),
        FT_FRAME_ULONG(Length),
        FT_FRAME_END
    };


    if (FT_STREAM_SEEK(offset))
        goto Exit;

    for (nn = 0; nn < sfnt->num_tables; nn++)
    {
        TT_TableRec table;


        if (FT_STREAM_READ_FIELDS(table_dir_entry_fields, &table))
        {
            nn--;
            FT_TRACE2(("check_table_dir:"
                       " can read only %d table%s in font (instead of %d)\n",
                       nn, nn == 1 ? "" : "s", sfnt->num_tables));
            sfnt->num_tables = nn;
            break;
        }

        /* we ignore invalid tables */
        if (table.Offset + table.Length > stream->size)
        {
            FT_TRACE2(("check_table_dir: table entry %d invalid\n", nn));
            continue;
        }
        else
            valid_entries++;

        if (table.Tag == TTAG_head || table.Tag == TTAG_bhed)
        {
            FT_UInt32 magic;


            #ifndef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
            if (table.Tag == TTAG_head)
            #endif
            has_head = 1;

            /*
             * The table length should be 0x36, but certain font tools make it
             * 0x38, so we will just check that it is greater.
             *
             * Note that according to the specification, the table must be
             * padded to 32-bit lengths, but this doesn't apply to the value of
             * its `Length' field!
             *
             */
            if (table.Length < 0x36)
            {
                FT_TRACE2(("check_table_dir: `head' table too small\n"));
                error = SFNT_Err_Table_Missing;
                goto Exit;
            }

            if (FT_STREAM_SEEK(table.Offset + 12) ||
                FT_READ_ULONG(magic))
                goto Exit;

            if (magic != 0x5F0F3CF5UL)
            {
                FT_TRACE2(("check_table_dir:"
                           " no magic number found in `head' table\n"));
                error = SFNT_Err_Table_Missing;
                goto Exit;
            }

            if (FT_STREAM_SEEK(offset + (nn + 1) * 16))
                goto Exit;
        }
        else if (table.Tag == TTAG_SING)
            has_sing = 1;
        else if (table.Tag == TTAG_META)
            has_meta = 1;
    }

    sfnt->num_tables = valid_entries;

    if (sfnt->num_tables == 0)
    {
        FT_TRACE2(("check_table_dir: no tables found\n"));
        error = SFNT_Err_Unknown_File_Format;
        goto Exit;
    }

    /* if `sing' and `meta' tables are present, there is no `head' table */
    if (has_head || (has_sing && has_meta))
    {
        error = SFNT_Err_Ok;
        goto Exit;
    }
    else
    {
        FT_TRACE2(("check_table_dir:"));
        #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
        FT_TRACE2((" neither `head', `bhed', nor `sing' table found\n"));
        #else
        FT_TRACE2((" neither `head' nor `sing' table found\n"));
        #endif
        error = SFNT_Err_Table_Missing;
    }

Exit:
    return error;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_font_dir                                              */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the header of a SFNT font file.                              */
/*                                                                       */
/* <Input>                                                               */
/*    face       :: A handle to the target face object.                  */
/*                                                                       */
/*    stream     :: The input stream.                                    */
/*                                                                       */
/* <Output>                                                              */
/*    sfnt       :: The SFNT header.                                     */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
/* <Note>                                                                */
/*    The stream cursor must be at the beginning of the font directory.  */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_load_font_dir(TT_Face face,
                      FT_Stream stream)
{
    SFNT_HeaderRec sfnt;
    FT_Error error;
    FT_Memory memory = stream->memory;
    TT_TableRec* entry;
    FT_Int nn;

    static const FT_Frame_Field offset_table_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE SFNT_HeaderRec

        FT_FRAME_START(8),
        FT_FRAME_USHORT(num_tables),
        FT_FRAME_USHORT(search_range),
        FT_FRAME_USHORT(entry_selector),
        FT_FRAME_USHORT(range_shift),
        FT_FRAME_END
    };


    FT_TRACE2(("tt_face_load_font_dir: %08p\n", face));

    /* read the offset table */

    sfnt.offset = FT_STREAM_POS();

    if (FT_READ_ULONG(sfnt.format_tag) ||
        FT_STREAM_READ_FIELDS(offset_table_fields, &sfnt))
        goto Exit;

    /* many fonts don't have these fields set correctly */
    #if 0
    if (sfnt.search_range != 1 << (sfnt.entry_selector + 4) ||
        sfnt.search_range + sfnt.range_shift != sfnt.num_tables << 4)
        return SFNT_Err_Unknown_File_Format;
    #endif

    /* load the table directory */

    FT_TRACE2(("-- Number of tables: %10u\n", sfnt.num_tables));
    FT_TRACE2(("-- Format version:   0x%08lx\n", sfnt.format_tag));

    /* check first */
    error = check_table_dir(&sfnt, stream);
    if (error)
    {
        FT_TRACE2(("tt_face_load_font_dir:"
                   " invalid table directory for TrueType\n"));

        goto Exit;
    }

    face->num_tables = sfnt.num_tables;
    face->format_tag = sfnt.format_tag;

    if (FT_QNEW_ARRAY(face->dir_tables, face->num_tables))
        goto Exit;

    if (FT_STREAM_SEEK(sfnt.offset + 12) ||
        FT_FRAME_ENTER(face->num_tables * 16L))
        goto Exit;

    entry = face->dir_tables;

    for (nn = 0; nn < sfnt.num_tables; nn++)
    {
        entry->Tag = FT_GET_TAG4();
        entry->CheckSum = FT_GET_ULONG();
        entry->Offset = FT_GET_LONG();
        entry->Length = FT_GET_LONG();

        /* ignore invalid tables */
        if (entry->Offset + entry->Length > stream->size)
            continue;
        else
        {
            FT_TRACE2(("  %c%c%c%c  -  %08lx  -  %08lx\n",
                       (FT_Char)(entry->Tag >> 24),
                       (FT_Char)(entry->Tag >> 16),
                       (FT_Char)(entry->Tag >> 8),
                       (FT_Char)(entry->Tag),
                       entry->Offset,
                       entry->Length));
            entry++;
        }
    }

    FT_FRAME_EXIT();

    FT_TRACE2(("table directory loaded\n\n"));

Exit:
    return error;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_any                                                   */
/*                                                                       */
/* <Description>                                                         */
/*    Loads any font table into client memory.                           */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: The face object to look for.                             */
/*                                                                       */
/*    tag    :: The tag of table to load.  Use the value 0 if you want   */
/*              to access the whole font file, else set this parameter   */
/*              to a valid TrueType table tag that you can forge with    */
/*              the MAKE_TT_TAG macro.                                   */
/*                                                                       */
/*    offset :: The starting offset in the table (or the file if         */
/*              tag == 0).                                               */
/*                                                                       */
/*    length :: The address of the decision variable:                    */
/*                                                                       */
/*                If length == NULL:                                     */
/*                  Loads the whole table.  Returns an error if          */
/*                  `offset' == 0!                                       */
/*                                                                       */
/*                If *length == 0:                                       */
/*                  Exits immediately; returning the length of the given */
/*                  table or of the font file, depending on the value of */
/*                  `tag'.                                               */
/*                                                                       */
/*                If *length != 0:                                       */
/*                  Loads the next `length' bytes of table or font,      */
/*                  starting at offset `offset' (in table or font too).  */
/*                                                                       */
/* <Output>                                                              */
/*    buffer :: The address of target buffer.                            */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_load_any(TT_Face face,
                 FT_ULong tag,
                 FT_Long offset,
                 FT_Byte * buffer,
                 FT_ULong * length)
{
    FT_Error error;
    FT_Stream stream;
    TT_Table table;
    FT_ULong size;


    if (tag != 0)
    {
        /* look for tag in font directory */
        table = tt_face_lookup_table(face, tag);
        if (!table)
        {
            error = SFNT_Err_Table_Missing;
            goto Exit;
        }

        offset += table->Offset;
        size = table->Length;
    }
    else
        /* tag == 0 -- the user wants to access the font file directly */
        size = face->root.stream->size;

    if (length && *length == 0)
    {
        *length = size;

        return SFNT_Err_Ok;
    }

    if (length)
        size = *length;

    stream = face->root.stream;
    /* the `if' is syntactic sugar for picky compilers */
    if (FT_STREAM_READ_AT(offset, buffer, size))
        goto Exit;

Exit:
    return error;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_generic_header                                        */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the TrueType table `head' or `bhed'.                         */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A handle to the target face object.                      */
/*                                                                       */
/*    stream :: The input stream.                                        */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
static FT_Error
tt_face_load_generic_header(TT_Face face,
                            FT_Stream stream,
                            FT_ULong tag)
{
    FT_Error error;
    TT_Header* header;

    static const FT_Frame_Field header_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE TT_Header

        FT_FRAME_START(54),
        FT_FRAME_ULONG(Table_Version),
        FT_FRAME_ULONG(Font_Revision),
        FT_FRAME_LONG(CheckSum_Adjust),
        FT_FRAME_LONG(Magic_Number),
        FT_FRAME_USHORT(Flags),
        FT_FRAME_USHORT(Units_Per_EM),
        FT_FRAME_LONG(Created[0]),
        FT_FRAME_LONG(Created[1]),
        FT_FRAME_LONG(Modified[0]),
        FT_FRAME_LONG(Modified[1]),
        FT_FRAME_SHORT(xMin),
        FT_FRAME_SHORT(yMin),
        FT_FRAME_SHORT(xMax),
        FT_FRAME_SHORT(yMax),
        FT_FRAME_USHORT(Mac_Style),
        FT_FRAME_USHORT(Lowest_Rec_PPEM),
        FT_FRAME_SHORT(Font_Direction),
        FT_FRAME_SHORT(Index_To_Loc_Format),
        FT_FRAME_SHORT(Glyph_Data_Format),
        FT_FRAME_END
    };


    error = face->goto_table(face, tag, stream, 0);
    if (error)
        goto Exit;

    header = &face->header;

    if (FT_STREAM_READ_FIELDS(header_fields, header))
        goto Exit;

    FT_TRACE3(("Units per EM: %4u\n", header->Units_Per_EM));
    FT_TRACE3(("IndexToLoc:   %4d\n", header->Index_To_Loc_Format));

Exit:
    return error;
}


FT_LOCAL_DEF(FT_Error)
tt_face_load_head(TT_Face face,
                  FT_Stream stream)
{
    return tt_face_load_generic_header(face, stream, TTAG_head);
}


#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS

FT_LOCAL_DEF(FT_Error)
tt_face_load_bhed(TT_Face face,
                  FT_Stream stream)
{
    return tt_face_load_generic_header(face, stream, TTAG_bhed);
}

#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_max_profile                                           */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the maximum profile into a face object.                      */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A handle to the target face object.                      */
/*                                                                       */
/*    stream :: The input stream.                                        */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_load_maxp(TT_Face face,
                  FT_Stream stream)
{
    FT_Error error;
    TT_MaxProfile* maxProfile = &face->max_profile;

    const FT_Frame_Field maxp_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE TT_MaxProfile

        FT_FRAME_START(6),
        FT_FRAME_LONG(version),
        FT_FRAME_USHORT(numGlyphs),
        FT_FRAME_END
    };

    const FT_Frame_Field maxp_fields_extra[] =
    {
        FT_FRAME_START(26),
        FT_FRAME_USHORT(maxPoints),
        FT_FRAME_USHORT(maxContours),
        FT_FRAME_USHORT(maxCompositePoints),
        FT_FRAME_USHORT(maxCompositeContours),
        FT_FRAME_USHORT(maxZones),
        FT_FRAME_USHORT(maxTwilightPoints),
        FT_FRAME_USHORT(maxStorage),
        FT_FRAME_USHORT(maxFunctionDefs),
        FT_FRAME_USHORT(maxInstructionDefs),
        FT_FRAME_USHORT(maxStackElements),
        FT_FRAME_USHORT(maxSizeOfInstructions),
        FT_FRAME_USHORT(maxComponentElements),
        FT_FRAME_USHORT(maxComponentDepth),
        FT_FRAME_END
    };


    error = face->goto_table(face, TTAG_maxp, stream, 0);
    if (error)
        goto Exit;

    if (FT_STREAM_READ_FIELDS(maxp_fields, maxProfile))
        goto Exit;

    maxProfile->maxPoints = 0;
    maxProfile->maxContours = 0;
    maxProfile->maxCompositePoints = 0;
    maxProfile->maxCompositeContours = 0;
    maxProfile->maxZones = 0;
    maxProfile->maxTwilightPoints = 0;
    maxProfile->maxStorage = 0;
    maxProfile->maxFunctionDefs = 0;
    maxProfile->maxInstructionDefs = 0;
    maxProfile->maxStackElements = 0;
    maxProfile->maxSizeOfInstructions = 0;
    maxProfile->maxComponentElements = 0;
    maxProfile->maxComponentDepth = 0;

    if (maxProfile->version >= 0x10000L)
    {
        if (FT_STREAM_READ_FIELDS(maxp_fields_extra, maxProfile))
            goto Exit;

        /* XXX: an adjustment that is necessary to load certain */
        /*      broken fonts like `Keystrokes MT' :-(           */
        /*                                                      */
        /*   We allocate 64 function entries by default when    */
        /*   the maxFunctionDefs field is null.                 */

        if (maxProfile->maxFunctionDefs == 0)
            maxProfile->maxFunctionDefs = 64;

        /* we add 4 phantom points later */
        if (maxProfile->maxTwilightPoints > (0xFFFFU - 4))
        {
            FT_TRACE0(("tt_face_load_maxp:"
                       " too much twilight points in `maxp' table;\n"
                       "                  "
                       " some glyphs might be rendered incorrectly\n"));

            maxProfile->maxTwilightPoints = 0xFFFFU - 4;
        }
    }

    FT_TRACE3(("numGlyphs: %u\n", maxProfile->numGlyphs));

Exit:
    return error;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_names                                                 */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the name records.                                            */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A handle to the target face object.                      */
/*                                                                       */
/*    stream :: The input stream.                                        */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_load_name(TT_Face face,
                  FT_Stream stream)
{
    FT_Error error;
    FT_Memory memory = stream->memory;
    FT_ULong table_pos, table_len;
    FT_ULong storage_start, storage_limit;
    FT_UInt count;
    TT_NameTable table;

    static const FT_Frame_Field name_table_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE TT_NameTableRec

        FT_FRAME_START(6),
        FT_FRAME_USHORT(format),
        FT_FRAME_USHORT(numNameRecords),
        FT_FRAME_USHORT(storageOffset),
        FT_FRAME_END
    };

    static const FT_Frame_Field name_record_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE TT_NameEntryRec

        /* no FT_FRAME_START */
        FT_FRAME_USHORT(platformID),
        FT_FRAME_USHORT(encodingID),
        FT_FRAME_USHORT(languageID),
        FT_FRAME_USHORT(nameID),
        FT_FRAME_USHORT(stringLength),
        FT_FRAME_USHORT(stringOffset),
        FT_FRAME_END
    };


    table = &face->name_table;
    table->stream = stream;

    error = face->goto_table(face, TTAG_name, stream, &table_len);
    if (error)
        goto Exit;

    table_pos = FT_STREAM_POS();


    if (FT_STREAM_READ_FIELDS(name_table_fields, table))
        goto Exit;

    /* Some popular Asian fonts have an invalid `storageOffset' value   */
    /* (it should be at least "6 + 12*num_names").  However, the string */
    /* offsets, computed as "storageOffset + entry->stringOffset", are  */
    /* valid pointers within the name table...                          */
    /*                                                                  */
    /* We thus can't check `storageOffset' right now.                   */
    /*                                                                  */
    storage_start = table_pos + 6 + 12 * table->numNameRecords;
    storage_limit = table_pos + table_len;

    if (storage_start > storage_limit)
    {
        FT_ERROR(("tt_face_load_name: invalid `name' table\n"));
        error = SFNT_Err_Name_Table_Missing;
        goto Exit;
    }

    /* Allocate the array of name records. */
    count = table->numNameRecords;
    table->numNameRecords = 0;

    if (FT_NEW_ARRAY(table->names, count) ||
        FT_FRAME_ENTER(count * 12))
        goto Exit;

    /* Load the name records and determine how much storage is needed */
    /* to hold the strings themselves.                                */
    {
        TT_NameEntryRec* entry = table->names;


        for (; count > 0; count--)
        {
            if (FT_STREAM_READ_FIELDS(name_record_fields, entry))
                continue;

            /* check that the name is not empty */
            if (entry->stringLength == 0)
                continue;

            /* check that the name string is within the table */
            entry->stringOffset += table_pos + table->storageOffset;
            if (entry->stringOffset < storage_start ||
                entry->stringOffset + entry->stringLength > storage_limit)
            {
                /* invalid entry - ignore it */
                entry->stringOffset = 0;
                entry->stringLength = 0;
                continue;
            }

            entry++;
        }

        table->numNameRecords = (FT_UInt)(entry - table->names);
    }

    FT_FRAME_EXIT();

    /* everything went well, update face->num_names */
    face->num_names = (FT_UShort)table->numNameRecords;

Exit:
    return error;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_free_names                                                 */
/*                                                                       */
/* <Description>                                                         */
/*    Frees the name records.                                            */
/*                                                                       */
/* <Input>                                                               */
/*    face :: A handle to the target face object.                        */
/*                                                                       */
FT_LOCAL_DEF(void)
tt_face_free_name(TT_Face face)
{
    FT_Memory memory = face->root.driver->root.memory;
    TT_NameTable table = &face->name_table;
    TT_NameEntry entry = table->names;
    FT_UInt count = table->numNameRecords;


    if (table->names)
    {
        for (; count > 0; count--, entry++)
        {
            FT_FREE(entry->string);
            entry->stringLength = 0;
        }

        /* free strings table */
        FT_FREE(table->names);
    }

    table->numNameRecords = 0;
    table->format = 0;
    table->storageOffset = 0;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_cmap                                                  */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the cmap directory in a face object.  The cmaps themselves   */
/*    are loaded on demand in the `ttcmap.c' module.                     */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A handle to the target face object.                      */
/*                                                                       */
/*    stream :: A handle to the input stream.                            */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */

FT_LOCAL_DEF(FT_Error)
tt_face_load_cmap(TT_Face face,
                  FT_Stream stream)
{
    FT_Error error;


    error = face->goto_table(face, TTAG_cmap, stream, &face->cmap_size);
    if (error)
        goto Exit;

    if (FT_FRAME_EXTRACT(face->cmap_size, face->cmap_table))
        face->cmap_size = 0;

Exit:
    return error;
}



/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_os2                                                   */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the OS2 table.                                               */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A handle to the target face object.                      */
/*                                                                       */
/*    stream :: A handle to the input stream.                            */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_load_os2(TT_Face face,
                 FT_Stream stream)
{
    FT_Error error;
    TT_OS2* os2;

    const FT_Frame_Field os2_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE TT_OS2

        FT_FRAME_START(78),
        FT_FRAME_USHORT(version),
        FT_FRAME_SHORT(xAvgCharWidth),
        FT_FRAME_USHORT(usWeightClass),
        FT_FRAME_USHORT(usWidthClass),
        FT_FRAME_SHORT(fsType),
        FT_FRAME_SHORT(ySubscriptXSize),
        FT_FRAME_SHORT(ySubscriptYSize),
        FT_FRAME_SHORT(ySubscriptXOffset),
        FT_FRAME_SHORT(ySubscriptYOffset),
        FT_FRAME_SHORT(ySuperscriptXSize),
        FT_FRAME_SHORT(ySuperscriptYSize),
        FT_FRAME_SHORT(ySuperscriptXOffset),
        FT_FRAME_SHORT(ySuperscriptYOffset),
        FT_FRAME_SHORT(yStrikeoutSize),
        FT_FRAME_SHORT(yStrikeoutPosition),
        FT_FRAME_SHORT(sFamilyClass),
        FT_FRAME_BYTE(panose[0]),
        FT_FRAME_BYTE(panose[1]),
        FT_FRAME_BYTE(panose[2]),
        FT_FRAME_BYTE(panose[3]),
        FT_FRAME_BYTE(panose[4]),
        FT_FRAME_BYTE(panose[5]),
        FT_FRAME_BYTE(panose[6]),
        FT_FRAME_BYTE(panose[7]),
        FT_FRAME_BYTE(panose[8]),
        FT_FRAME_BYTE(panose[9]),
        FT_FRAME_ULONG(ulUnicodeRange1),
        FT_FRAME_ULONG(ulUnicodeRange2),
        FT_FRAME_ULONG(ulUnicodeRange3),
        FT_FRAME_ULONG(ulUnicodeRange4),
        FT_FRAME_BYTE(achVendID[0]),
        FT_FRAME_BYTE(achVendID[1]),
        FT_FRAME_BYTE(achVendID[2]),
        FT_FRAME_BYTE(achVendID[3]),

        FT_FRAME_USHORT(fsSelection),
        FT_FRAME_USHORT(usFirstCharIndex),
        FT_FRAME_USHORT(usLastCharIndex),
        FT_FRAME_SHORT(sTypoAscender),
        FT_FRAME_SHORT(sTypoDescender),
        FT_FRAME_SHORT(sTypoLineGap),
        FT_FRAME_USHORT(usWinAscent),
        FT_FRAME_USHORT(usWinDescent),
        FT_FRAME_END
    };

    const FT_Frame_Field os2_fields_extra[] =
    {
        FT_FRAME_START(8),
        FT_FRAME_ULONG(ulCodePageRange1),
        FT_FRAME_ULONG(ulCodePageRange2),
        FT_FRAME_END
    };

    const FT_Frame_Field os2_fields_extra2[] =
    {
        FT_FRAME_START(10),
        FT_FRAME_SHORT(sxHeight),
        FT_FRAME_SHORT(sCapHeight),
        FT_FRAME_USHORT(usDefaultChar),
        FT_FRAME_USHORT(usBreakChar),
        FT_FRAME_USHORT(usMaxContext),
        FT_FRAME_END
    };


    /* We now support old Mac fonts where the OS/2 table doesn't  */
    /* exist.  Simply put, we set the `version' field to 0xFFFF   */
    /* and test this value each time we need to access the table. */
    error = face->goto_table(face, TTAG_OS2, stream, 0);
    if (error)
        goto Exit;

    os2 = &face->os2;

    if (FT_STREAM_READ_FIELDS(os2_fields, os2))
        goto Exit;

    os2->ulCodePageRange1 = 0;
    os2->ulCodePageRange2 = 0;
    os2->sxHeight = 0;
    os2->sCapHeight = 0;
    os2->usDefaultChar = 0;
    os2->usBreakChar = 0;
    os2->usMaxContext = 0;

    if (os2->version >= 0x0001)
    {
        /* only version 1 tables */
        if (FT_STREAM_READ_FIELDS(os2_fields_extra, os2))
            goto Exit;

        if (os2->version >= 0x0002)
        {
            /* only version 2 tables */
            if (FT_STREAM_READ_FIELDS(os2_fields_extra2, os2))
                goto Exit;
        }
    }

    FT_TRACE3(("sTypoAscender:  %4d\n", os2->sTypoAscender));
    FT_TRACE3(("sTypoDescender: %4d\n", os2->sTypoDescender));
    FT_TRACE3(("usWinAscent:    %4u\n", os2->usWinAscent));
    FT_TRACE3(("usWinDescent:   %4u\n", os2->usWinDescent));
    FT_TRACE3(("fsSelection:    0x%2x\n", os2->fsSelection));

Exit:
    return error;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_postscript                                            */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the Postscript table.                                        */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A handle to the target face object.                      */
/*                                                                       */
/*    stream :: A handle to the input stream.                            */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_load_post(TT_Face face,
                  FT_Stream stream)
{
    FT_Error error;
    TT_Postscript* post = &face->postscript;

    static const FT_Frame_Field post_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE TT_Postscript

        FT_FRAME_START(32),
        FT_FRAME_ULONG(FormatType),
        FT_FRAME_ULONG(italicAngle),
        FT_FRAME_SHORT(underlinePosition),
        FT_FRAME_SHORT(underlineThickness),
        FT_FRAME_ULONG(isFixedPitch),
        FT_FRAME_ULONG(minMemType42),
        FT_FRAME_ULONG(maxMemType42),
        FT_FRAME_ULONG(minMemType1),
        FT_FRAME_ULONG(maxMemType1),
        FT_FRAME_END
    };


    error = face->goto_table(face, TTAG_post, stream, 0);
    if (error)
        return error;

    if (FT_STREAM_READ_FIELDS(post_fields, post))
        return error;

    /* we don't load the glyph names, we do that in another */
    /* module (ttpost).                                     */

    FT_TRACE3(("FormatType:   0x%x\n", post->FormatType));
    FT_TRACE3(("isFixedPitch:   %s\n", post->isFixedPitch
               ? "  yes" : "   no"));

    return SFNT_Err_Ok;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_pclt                                                  */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the PCL 5 Table.                                             */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A handle to the target face object.                      */
/*                                                                       */
/*    stream :: A handle to the input stream.                            */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_load_pclt(TT_Face face,
                  FT_Stream stream)
{
    static const FT_Frame_Field pclt_fields[] =
    {
        #undef  FT_STRUCTURE
#define FT_STRUCTURE TT_PCLT

        FT_FRAME_START(54),
        FT_FRAME_ULONG(Version),
        FT_FRAME_ULONG(FontNumber),
        FT_FRAME_USHORT(Pitch),
        FT_FRAME_USHORT(xHeight),
        FT_FRAME_USHORT(Style),
        FT_FRAME_USHORT(TypeFamily),
        FT_FRAME_USHORT(CapHeight),
        FT_FRAME_BYTES(TypeFace, 16),
        FT_FRAME_BYTES(CharacterComplement, 8),
        FT_FRAME_BYTES(FileName, 6),
        FT_FRAME_CHAR(StrokeWeight),
        FT_FRAME_CHAR(WidthType),
        FT_FRAME_BYTE(SerifStyle),
        FT_FRAME_BYTE(Reserved),
        FT_FRAME_END
    };

    FT_Error error;
    TT_PCLT* pclt = &face->pclt;


    /* optional table */
    error = face->goto_table(face, TTAG_PCLT, stream, 0);
    if (error)
        goto Exit;

    if (FT_STREAM_READ_FIELDS(pclt_fields, pclt))
        goto Exit;

Exit:
    return error;
}


/*************************************************************************/
/*                                                                       */
/* <Function>                                                            */
/*    tt_face_load_gasp                                                  */
/*                                                                       */
/* <Description>                                                         */
/*    Loads the `gasp' table into a face object.                         */
/*                                                                       */
/* <Input>                                                               */
/*    face   :: A handle to the target face object.                      */
/*                                                                       */
/*    stream :: The input stream.                                        */
/*                                                                       */
/* <Return>                                                              */
/*    FreeType error code.  0 means success.                             */
/*                                                                       */
FT_LOCAL_DEF(FT_Error)
tt_face_load_gasp(TT_Face face,
                  FT_Stream stream)
{
    FT_Error error;
    FT_Memory memory = stream->memory;

    FT_UInt j, num_ranges;
    TT_GaspRange gaspranges;


    /* the gasp table is optional */
    error = face->goto_table(face, TTAG_gasp, stream, 0);
    if (error)
        goto Exit;

    if (FT_FRAME_ENTER(4L))
        goto Exit;

    face->gasp.version = FT_GET_USHORT();
    face->gasp.numRanges = FT_GET_USHORT();

    FT_FRAME_EXIT();

    /* only support versions 0 and 1 of the table */
    if (face->gasp.version >= 2)
    {
        face->gasp.numRanges = 0;
        error = SFNT_Err_Invalid_Table;
        goto Exit;
    }

    num_ranges = face->gasp.numRanges;
    FT_TRACE3(("numRanges: %u\n", num_ranges));

    if (FT_QNEW_ARRAY(gaspranges, num_ranges) ||
        FT_FRAME_ENTER(num_ranges * 4L))
        goto Exit;

    face->gasp.gaspRanges = gaspranges;

    for (j = 0; j < num_ranges; j++)
    {
        gaspranges[j].maxPPEM = FT_GET_USHORT();
        gaspranges[j].gaspFlag = FT_GET_USHORT();

        FT_TRACE3(("gaspRange %d: rangeMaxPPEM %5d, rangeGaspBehavior 0x%x\n",
                   j,
                   gaspranges[j].maxPPEM,
                   gaspranges[j].gaspFlag));
    }

    FT_FRAME_EXIT();

Exit:
    return error;
}


/* END */